home *** CD-ROM | disk | FTP | other *** search
/ Personal Computer World 2005 October / PCWOCT05.iso / Software / FromTheMag / XAMPP 1.4.14 / xampp-win32-1.4.14-installer.exe / xampp / php / pear / HTML / QuickForm / file.php < prev    next >
PHP Script  |  2004-10-01  |  11KB  |  343 lines
  1. <?php
  2. /* vim: set expandtab tabstop=4 shiftwidth=4: */
  3. // +----------------------------------------------------------------------+
  4. // | PHP version 4.0                                                      |
  5. // +----------------------------------------------------------------------+
  6. // | Copyright (c) 1997, 1998, 1999, 2000, 2001 The PHP Group             |
  7. // +----------------------------------------------------------------------+
  8. // | This source file is subject to version 2.0 of the PHP license,       |
  9. // | that is bundled with this package in the file LICENSE, and is        |
  10. // | available at through the world-wide-web at                           |
  11. // | http://www.php.net/license/2_02.txt.                                 |
  12. // | If you did not receive a copy of the PHP license and are unable to   |
  13. // | obtain it through the world-wide-web, please send a note to          |
  14. // | license@php.net so we can mail you a copy immediately.               |
  15. // +----------------------------------------------------------------------+
  16. // | Authors: Adam Daniel <adaniel1@eesus.jnj.com>                        |
  17. // |          Bertrand Mansion <bmansion@mamasam.com>                     |
  18. // +----------------------------------------------------------------------+
  19. //
  20. // $Id: file.php,v 1.18 2003/11/01 15:03:50 avb Exp $
  21.  
  22. require_once("HTML/QuickForm/input.php");
  23.  
  24. // register file-related rules
  25. if (class_exists('HTML_QuickForm')) {
  26.     HTML_QuickForm::registerRule('uploadedfile', 'callback', '_ruleIsUploadedFile', 'HTML_QuickForm_file');
  27.     HTML_QuickForm::registerRule('maxfilesize', 'callback', '_ruleCheckMaxFileSize', 'HTML_QuickForm_file');
  28.     HTML_QuickForm::registerRule('mimetype', 'callback', '_ruleCheckMimeType', 'HTML_QuickForm_file');
  29.     HTML_QuickForm::registerRule('filename', 'callback', '_ruleCheckFileName', 'HTML_QuickForm_file');
  30. }
  31.  
  32. /**
  33.  * HTML class for a file type element
  34.  * 
  35.  * @author       Adam Daniel <adaniel1@eesus.jnj.com>
  36.  * @author       Bertrand Mansion <bmansion@mamasam.com>
  37.  * @version      1.0
  38.  * @since        PHP4.04pl1
  39.  * @access       public
  40.  */
  41. class HTML_QuickForm_file extends HTML_QuickForm_input
  42. {
  43.     // {{{ properties
  44.  
  45.    /**
  46.     * Uploaded file data, from $_FILES
  47.     * @var array
  48.     */
  49.     var $_value = null;
  50.  
  51.     // }}}
  52.     // {{{ constructor
  53.  
  54.     /**
  55.      * Class constructor
  56.      * 
  57.      * @param     string    Input field name attribute
  58.      * @param     string    Input field label
  59.      * @param     mixed     (optional)Either a typical HTML attribute string 
  60.      *                      or an associative array
  61.      * @since     1.0
  62.      * @access    public
  63.      */
  64.     function HTML_QuickForm_file($elementName=null, $elementLabel=null, $attributes=null)
  65.     {
  66.         HTML_QuickForm_input::HTML_QuickForm_input($elementName, $elementLabel, $attributes);
  67.         $this->setType('file');
  68.     } //end constructor
  69.     
  70.     // }}}
  71.     // {{{ setSize()
  72.  
  73.     /**
  74.      * Sets size of file element
  75.      * 
  76.      * @param     int    Size of file element
  77.      * @since     1.0
  78.      * @access    public
  79.      */
  80.     function setSize($size)
  81.     {
  82.         $this->updateAttributes(array('size' => $size));
  83.     } //end func setSize
  84.     
  85.     // }}}
  86.     // {{{ getSize()
  87.  
  88.     /**
  89.      * Returns size of file element
  90.      * 
  91.      * @since     1.0
  92.      * @access    public
  93.      * @return    int
  94.      */
  95.     function getSize()
  96.     {
  97.         return $this->getAttribute('size');
  98.     } //end func getSize
  99.  
  100.     // }}}
  101.     // {{{ freeze()
  102.  
  103.     /**
  104.      * Freeze the element so that only its value is returned
  105.      * 
  106.      * @access    public
  107.      * @return    bool
  108.      */
  109.     function freeze()
  110.     {
  111.         return false;
  112.     } //end func freeze
  113.  
  114.     // }}}
  115.     // {{{ setValue()
  116.  
  117.     /**
  118.      * Sets value for file element.
  119.      * 
  120.      * Actually this does nothing. The function is defined here to override
  121.      * HTML_Quickform_input's behaviour of setting the 'value' attribute. As
  122.      * no sane user-agent uses <input type="file">'s value for anything 
  123.      * (because of security implications) we implement file's value as a 
  124.      * read-only property with a special meaning.
  125.      * 
  126.      * @param     mixed    Value for file element
  127.      * @since     3.0
  128.      * @access    public
  129.      */
  130.     function setValue($value)
  131.     {
  132.         return null;
  133.     } //end func setValue
  134.     
  135.     // }}}
  136.     // {{{ getValue()
  137.  
  138.     /**
  139.      * Returns information about the uploaded file
  140.      *
  141.      * @since     3.0
  142.      * @access    public
  143.      * @return    array
  144.      */
  145.     function getValue()
  146.     {
  147.         return $this->_value;
  148.     } // end func getValue
  149.  
  150.     // }}}
  151.     // {{{ onQuickFormEvent()
  152.  
  153.     /**
  154.      * Called by HTML_QuickForm whenever form event is made on this element
  155.      *
  156.      * @param     string    Name of event
  157.      * @param     mixed     event arguments
  158.      * @param     object    calling object
  159.      * @since     1.0
  160.      * @access    public
  161.      * @return    bool
  162.      */
  163.     function onQuickFormEvent($event, $arg, &$caller)
  164.     {
  165.         switch ($event) {
  166.             case 'updateValue':
  167.                 if ($caller->getAttribute('method') == 'get') {
  168.                     return PEAR::raiseError('Cannot add a file upload field to a GET method form');
  169.                 }
  170.                 $this->_value = $this->_findValue();
  171.                 $caller->updateAttributes(array('enctype' => 'multipart/form-data'));
  172.                 $caller->setMaxFileSize();
  173.                 break;
  174.             case 'addElement':
  175.                 $this->onQuickFormEvent('createElement', $arg, $caller);
  176.                 return $this->onQuickFormEvent('updateValue', null, $caller);
  177.                 break;
  178.             case 'createElement':
  179.                 $className = get_class($this);
  180.                 $this->$className($arg[0], $arg[1], $arg[2]);
  181.                 break;
  182.         }
  183.         return true;
  184.     } // end func onQuickFormEvent
  185.  
  186.     // }}}
  187.     // {{{ moveUploadedFile()
  188.  
  189.     /**
  190.      * Moves an uploaded file into the destination 
  191.      * 
  192.      * @param    string  Destination directory path
  193.      * @param    string  New file name
  194.      * @access   public
  195.      */
  196.     function moveUploadedFile($dest, $fileName = '')
  197.     {
  198.         if ($dest != ''  && substr($dest, -1) != '/') {
  199.             $dest .= '/';
  200.         }
  201.         $fileName = ($fileName != '') ? $fileName : basename($this->_value['name']);
  202.         if (move_uploaded_file($this->_value['tmp_name'], $dest . $fileName)) {
  203.             return true;
  204.         } else {
  205.             return false;
  206.         }
  207.     } // end func moveUploadedFile
  208.     
  209.     // }}}
  210.     // {{{ isUploadedFile()
  211.  
  212.     /**
  213.      * Checks if the element contains an uploaded file
  214.      *
  215.      * @access    public
  216.      * @return    bool      true if file has been uploaded, false otherwise
  217.      */
  218.     function isUploadedFile()
  219.     {
  220.         return $this->_ruleIsUploadedFile($this->_value);
  221.     } // end func isUploadedFile
  222.  
  223.     // }}}
  224.     // {{{ _ruleIsUploadedFile()
  225.  
  226.     /**
  227.      * Checks if the given element contains an uploaded file
  228.      *
  229.      * @param     array     Uploaded file info (from $_FILES)
  230.      * @access    private
  231.      * @return    bool      true if file has been uploaded, false otherwise
  232.      */
  233.     function _ruleIsUploadedFile($elementValue)
  234.     {
  235.         if ((isset($elementValue['error']) && $elementValue['error'] == 0) ||
  236.             (!empty($elementValue['tmp_name']) && $elementValue['tmp_name'] != 'none')) {
  237.             return is_uploaded_file($elementValue['tmp_name']);
  238.         } else {
  239.             return false;
  240.         }
  241.     } // end func _ruleIsUploadedFile
  242.     
  243.     // }}}
  244.     // {{{ _ruleCheckMaxFileSize()
  245.  
  246.     /**
  247.      * Checks that the file does not exceed the max file size
  248.      *
  249.      * @param     array     Uploaded file info (from $_FILES)
  250.      * @param     int       Max file size
  251.      * @access    private
  252.      * @return    bool      true if filesize is lower than maxsize, false otherwise
  253.      */
  254.     function _ruleCheckMaxFileSize($elementValue, $maxSize)
  255.     {
  256.         if (!HTML_QuickForm_file::_ruleIsUploadedFile($elementValue)) {
  257.             return true;
  258.         }
  259.         return ($maxSize >= @filesize($elementValue['tmp_name']));
  260.     } // end func _ruleCheckMaxFileSize
  261.  
  262.     // }}}
  263.     // {{{ _ruleCheckMimeType()
  264.  
  265.     /**
  266.      * Checks if the given element contains an uploaded file of the right mime type
  267.      *
  268.      * @param     array     Uploaded file info (from $_FILES)
  269.      * @param     mixed     Mime Type (can be an array of allowed types)
  270.      * @access    private
  271.      * @return    bool      true if mimetype is correct, false otherwise
  272.      */
  273.     function _ruleCheckMimeType($elementValue, $mimeType)
  274.     {
  275.         if (!HTML_QuickForm_file::_ruleIsUploadedFile($elementValue)) {
  276.             return true;
  277.         }
  278.         if (is_array($mimeType)) {
  279.             return in_array($elementValue['type'], $mimeType);
  280.         }
  281.         return $elementValue['type'] == $mimeType;
  282.     } // end func _ruleCheckMimeType
  283.  
  284.     // }}}
  285.     // {{{ _ruleCheckFileName()
  286.  
  287.     /**
  288.      * Checks if the given element contains an uploaded file of the filename regex
  289.      *
  290.      * @param     array     Uploaded file info (from $_FILES)
  291.      * @param     string    Regular expression
  292.      * @access    private
  293.      * @return    bool      true if name matches regex, false otherwise
  294.      */
  295.     function _ruleCheckFileName($elementValue, $regex)
  296.     {
  297.         if (!HTML_QuickForm_file::_ruleIsUploadedFile($elementValue)) {
  298.             return true;
  299.         }
  300.         return preg_match($regex, $elementValue['name']);
  301.     } // end func _ruleCheckFileName
  302.     
  303.     // }}}
  304.     // {{{ _findValue()
  305.  
  306.    /**
  307.     * Tries to find the element value from the values array
  308.     * 
  309.     * Needs to be redefined here as $_FILES is populated differently from 
  310.     * other arrays when element name is of the form foo[bar]
  311.     * 
  312.     * @access    private
  313.     * @return    mixed
  314.     */
  315.     function _findValue()
  316.     {
  317.         if (empty($_FILES)) {
  318.             return null;
  319.         }
  320.         $elementName = $this->getName();
  321.         if (isset($_FILES[$elementName])) {
  322.             return $_FILES[$elementName];
  323.         } elseif (false !== ($pos = strpos($elementName, '['))) {
  324.             $base  = substr($elementName, 0, $pos);
  325.             $idx   = "['" . str_replace(array(']', '['), array('', "']['"), substr($elementName, $pos + 1, -1)) . "']";
  326.             $props = array('name', 'type', 'size', 'tmp_name', 'error');
  327.             $code  = "if (!isset(\$_FILES['{$base}']['name']{$idx})) {\n" .
  328.                      "    return null;\n" .
  329.                      "} else {\n" .
  330.                      "    \$value = array();\n";
  331.             foreach ($props as $prop) {
  332.                 $code .= "    \$value['{$prop}'] = \$_FILES['{$base}']['{$prop}']{$idx};\n";
  333.             }
  334.             return eval($code . "    return \$value;\n}\n");
  335.         } else {
  336.             return null;
  337.         }
  338.     }
  339.  
  340.     // }}}
  341. } // end class HTML_QuickForm_file
  342. ?>
  343.